import { get_lid } from "@Utils/getPageDecrypt"
import axios from "axios"
import { message } from '@bytedance/mona-ui';

import { store } from "~store"
import { Modal } from "@bytedance/mona-ui"
const service = axios.create({
  baseURL: "https://fxg.jinritemai.com/",
  timeout: 5 * 1000,
  retry: 10, //设置全局重试请求次数（最多重试几次请求）
  retryDelay: 1, //设置全局请求间隔
  retrySu: 5,
  retrySuDelay: 2000
})
// console.log("配置网络请求")
// http请求拦截
service.interceptors.request.use(
  (config) => {
    // console.log("配置网络请求++", config)

    if (config.paramete) {
      const { __token, msToken } = store.getState().jinritemaiDecrypt
      config.paramete.__token = __token
      config.paramete._bid = config.paramete._bid || "ffa_goods"
      config.paramete._lid = get_lid()
      config.paramete.appid = 1
      config.paramete._ = new Date().getTime()
      config.paramete.msToken = msToken
      if (!/\?/.test(config.url)) {
        let str = splitJoint(config.paramete)
        config.url += str
        if (config.method == "GET" || config.method == "get") {
          config.data = undefined
        }
      }
    }
    // console.log('configurl', config.url)
    return config
  },
  (error) => {
    // Do something with request error
    Promise.reject(error)
  }
)
function splitJoint(obj) {
  let arr = []
  for (let key in obj) {
    arr.push(key + "=" + obj[key])
  }
  return arr.length > 0 ? "?" + arr.join("&") : ""
}
let reloginTime = null
// response 拦截器
service.interceptors.response.use(
  (response) => {
    if (response.data.code == '10008') {
      if (location.pathname == '/' || location.pathname == '/login/common' || location.hostname !== 'fxg.jinritemai.com') {
        return response.data
      }
      if (reloginTime) {
        clearTimeout(reloginTime)
        reloginTime = null
      }
      reloginTime = setTimeout(_ => {
        Modal.confirm({
          title: '登陆过期',
          content: '登陆已过期，请登陆后重试',
          icon: null,
          okText: '刷新',
          cancelText: " 取消",
          onOk: () => {
            // open(getSchearData.data.url)
            location.reload()
            return
          }
        })
      }, 800)
      Promise.reject({
        type: "warning",
        msg: "登陆过期",
        smsg: response.data.msg
      })
    }
    // console.log('response', response)
    // || response.data.code == '10001010A'   频繁
    if (response.data.code == '10001010A') {
      return {
        code: response.data.code,
        config: response.config
      }
    }
    if (response.data.code == "-10000" || response.data.code == "-100000" || response.data.code == '-100004' || response.data.code == '500') {
      let config = response.config
      config.__retrySuCount = config.__retrySuCount || 0
      if (config.__retrySuCount >= config.retrySu) {
        // message.error('接口重试多次失败')
        return Promise.reject({
          type: "warning",
          msg: "接口重试多次失败",
          smsg: response.data.msg
        })
        // return response.data
      }
      // console.log('失败重试')
      config.__retrySuCount += 1

      // 设置请求间隔 在发送下一次请求之前停留一段时间，时间为上方设置好的请求间隔时间
      let backoff = new Promise(function (resolve) {
        setTimeout(function () {
          resolve()
        }, config.retrySuDelay || 1)
      })

      // 再次发送请求
      return backoff.then(function () {
        return service(config)
      })
    }
    return response.data
  },
  (error) => {
    let config = error.config
    if (!config || !config.retry) return Promise.reject(error)
    // console.log('error.response', error.response)
    // console.log('error.response', error)
    //如果有响应内容，就直接返回错误信息，不再发送请求
    // if (error.response && error.response.data) {
    //   return Promise.reject({ type: "error", msg: error.response.data })
    // }

    config.__retryCount = config.__retryCount || 0

    // 如果当前发送的请求大于等于设置好的请求次数时，不再发送请求，返回最终的错误信息
    if (config.__retryCount >= config.retry) {
      if (error.message === "Network Error") {
        //message为"Network Error"代表断网了
        message.error('网络连接已断开，请检查网络')
        return Promise.reject({
          type: "warning",
          msg: "网络连接已断开，请检查网络"
        })
      } else if (error.message === "timeout of 40000ms exceeded") {
        //网太慢了，5秒内没有接收到数据，这里的5000ms对应上方timeout设置的值
        message.error('请求超时，请检查网络')

        return Promise.reject({ type: "warning", msg: "请求超时，请检查网络" })
      } else {
        //除以上两种以外的所有错误，包括接口报错 400 500 之类的
        return Promise.reject({ type: "error", msg: "出现错误，请稍后再试" })
      }
    }

    // 记录请求次数+1
    config.__retryCount += 1

    // 设置请求间隔 在发送下一次请求之前停留一段时间，时间为上方设置好的请求间隔时间
    let backoff = new Promise(function (resolve) {
      setTimeout(function () {
        resolve()
      }, config.retryDelay || 1)
    })

    // 再次发送请求
    return backoff.then(function () {
      return service(config)
    })
    // return Promise.reject(error)
  }
)
// console.log('Add000*****0000*service', service)
window.addEventListener('message', (event) => {
  if (event.data && event.data.method === "getHttpWins") {
    // console.log('event.data', event.data)
    service(event.data.body).then((res) => {
      // console.log('res', res)
      res.body = event.data.body
      window.parent.postMessage(
        {
          method: "setHttpWins",
          data: res
        },
        "*"
      )
    })
  }
})
export default service
